Was ist der Operator "->" in C ++?

-> ist kein Operator. Es sind in der Tat zwei separate Operatoren, - und>.
Der Code der Bedingung dekrementiert x, während der ursprüngliche (nicht dekrementierte) Wert von x zurückgegeben wird, und vergleicht dann den ursprünglichen Wert mit 0 mit dem Operator>.
Zum besseren Verständnis könnte die Erklärung wie folgt geschrieben werden:
während ((x--)> 0)
|
Oder für etwas ganz anderes ... x rutscht auf 0.
während (x - \
\.
\.
\.
> 0)
printf ("% d", x);
Nicht so mathematisch, aber ... jedes Bild sagt mehr als tausend Worte ...
|
Das ist ein sehr komplizierter Operator, daher hat sogar ISO / IEC JTC1 (Joint Technical Committee 1) seine Beschreibung in zwei verschiedenen Teilen des C ++ - Standards platziert.
Scherz beiseite, es handelt sich um zwei verschiedene Operatoren: - und>, die jeweils in §5.2.6 / 2 und §5.9 des C ++ 03-Standards beschrieben sind.
|
Es ist gleichbedeutend mit
während (x--> 0)
x-- (nach dem Dekrementieren) entspricht x = x-1, daher wandelt sich der Code in Folgendes um:
während (x> 0) {
x = x-1;
// Logik
}}
x--; // Die Nachdekrementierung erfolgt, wenn x <= 0 ist
|
x kann in der entgegengesetzten Richtung noch schneller auf Null gehen:
int x = 10;
während (0 <---- x)
{
printf ("% d", x);
}}
8 6 4 2
Sie können die Geschwindigkeit mit einem Pfeil steuern!
int x = 100;
while (0 <-------------------- x)
{
printf ("% d", x);
}}
90 80 70 60 50 40 30 20 10
;)
|
Es ist
#include 
int main (void) {
int x = 10;
während (x--> 0) {// x auf 0 geht
printf ("% d", x);
}}
return 0;
}}
Nur der Raum lässt die Dinge lustig aussehen, - dekrementiert und vergleicht.
|
Die Verwendung von -> hat historische Relevanz. Das Inkrementieren war (und ist in einigen Fällen immer noch) schneller als das Inkrementieren in der x86-Architektur. Die Verwendung von -> legt nahe, dass x auf 0 geht, und spricht diejenigen mit mathematischem Hintergrund an.
|
während (x--> 0)
ist, wie das analysiert wird.
|
Äußerster Geek, aber ich werde dies verwenden:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
mache printf ("n ist% d \ n", n) als (n -> 0);
return 0;
}}
|
In einem Buch, das ich gelesen habe (ich weiß nicht mehr genau, welches Buch), heißt es: Compiler versuchen, Ausdrücke mithilfe der Regel von links nach rechts auf das größte Token zu analysieren.
In diesem Fall lautet der Ausdruck:
x -> 0
Analysiert die größten Token:
Token 1: x
Token 2: -
Token 3:>
Token 4: 0
Schlussfolgerung: x--> 0
Die gleiche Regel gilt für diesen Ausdruck:
a ----- b
Nach dem Parsen:
Token 1: a
Token 2: -
Token 3: -
Token 4: -
Token 5: b
Schlussfolgerung: (a -) - - b
Ich hoffe das hilft den komplizierten Ausdruck zu verstehen ^^
|
Dies ist genau das gleiche wie
während (x--)
{
printf ("% d", x);
}}
für nicht negative Zahlen
|
Wie auch immer, wir haben jetzt einen "Gehe zu" -Operator. "->" ist leicht als Richtung zu merken, und "während x auf Null geht" ist bedeutungsgerade.
Darüber hinaus ist es auf einigen Plattformen etwas effizienter als "für (x = 10; x> 0; x -)".
|
Dieser Code vergleicht zuerst x und 0 und dekrementiert dann x. (Auch in der ersten Antwort gesagt: Sie dekrementieren x nach und vergleichen dann x und 0 mit dem Operator>.) Siehe die Ausgabe dieses Codes:
9 8 7 6 5 4 3 2 1 0
Wir vergleichen und dekrementieren jetzt zuerst, indem wir 0 in der Ausgabe sehen.
Wenn wir zuerst dekrementieren und dann vergleichen möchten, verwenden Sie diesen Code:
#include 
int main (nichtig)
{
int x = 10;
während (--x> 0) // x auf 0 geht
{
printf ("% d", x);
}}
return 0;
}}
Diese Ausgabe ist:
9 8 7 6 5 4 3 2 1
|
Mein Compiler druckt 9876543210 aus, wenn ich diesen Code ausführe.
#include 
int main ()
{
int x = 10;
während (x -> 0) // x auf 0 geht
{
std :: cout << x;
}}
}}
Wie erwartet. Das while (x--> 0) bedeutet tatsächlich while (x> 0). Der x-- Post dekrementiert x.
während (x> 0)
{
x--;
std :: cout << x;
}}
ist eine andere Art, dasselbe zu schreiben.
Es ist schön, dass das Original wie "während x auf 0 geht" aussieht.
|
Zwischen - und> fehlt ein Leerzeichen. x wird nachträglich dekrementiert, dh nach Überprüfung der Bedingung x> 0? dekrementiert.
|
- ist der Dekrementierungsoperator und> ist der Operator größer als.
Die beiden Operatoren werden wie -> als ein einziger angewendet.
|
Es ist eine Kombination aus zwei Operatoren. Erstens - dient zum Dekrementieren des Werts und> zum Überprüfen, ob der Wert größer als der rechte Operand ist.
#include 
int main ()
{
int x = 10;
während (x--> 0)
printf ("% d", x);
return 0;
}}
Die Ausgabe wird sein:
9 8 7 6 5 4 3 2 1 0
|
Tatsächlich wird x nachdekrementiert und mit dieser Bedingung überprüft. Es ist nicht ->, es ist (x--)> 0
Hinweis: Der Wert von x wird geändert, nachdem die Bedingung überprüft wurde, da er nach dem Dekrementieren erfolgt. Einige ähnliche Fälle können auch auftreten, zum Beispiel:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C und C ++ befolgen die "Maximum Munch" -Regel. Genauso wie a --- b in (a--) - b übersetzt wird, bedeutet in Ihrem Fall x -> 0 (x -)> 0.
Die Regel besagt im Wesentlichen, dass Ausdrücke von links nach rechts gebildet werden, indem das Maximum an Zeichen verwendet wird, die einen gültigen Ausdruck bilden.
|
Warum all die Komplikationen?
Die einfache Antwort auf die ursprüngliche Frage lautet nur:
#include 
int main ()
{
int x = 10;
während (x>0)
{
printf ("% d", x);
x = x-1;
}}
}}
Es macht das Gleiche. Ich sage nicht, dass Sie es so machen sollten, aber es macht das gleiche und hätte die Frage in einem Beitrag beantwortet.
Das x-- ist nur eine Abkürzung für das Obige und> ist nur ein normaler Operator, der größer als ist. Kein großes Rätsel!
Es gibt heutzutage zu viele Leute, die einfache Dinge kompliziert machen;)
|
Auf herkömmliche Weise würden wir eine Bedingung in der Klammer der while-Schleife () und eine Abschlussbedingung in den geschweiften Klammern {} definieren, aber -> definiert beide gleichzeitig.
Zum Beispiel:
int abc (nichtig)
{
int a = 5
while ((a--)> 0) // Dekrementieren und vergleichen Sie beide gleichzeitig
{
// Code
}}
}}
Dies dekrementiert a und führt die Schleife aus, während a größer als 0 ist.
Herkömmlicherweise wäre es wie:
int abc (nichtig)
{
int a = 5;
während (a> 0)
{
ein--;
// Code
}}
ein--;
}}
In beiden Fällen tun wir dasselbe und erreichen dieselben Ziele.
|
(x -> 0) bedeutet (x -> 0).
Sie können (x ->) verwenden. Ausgabe: 9 8 7 6 5 4 3 2 1 0
Sie können (- x> 0) verwenden. Es ist Mittelwert (--x> 0) Ausgabe: 9 8 7 6 5 4 3 2 1
Sie können verwenden
(- \
\.
x> 0)
Ausgabe: 9 8 7 6 5 4 3 2 1
Sie können verwenden
(\
\.
x -> 0)
Ausgabe: 9 8 7 6 5 4 3 2 1 0
Sie können verwenden
(\
\.
x -> 0
\.
\.
)
Ausgabe: 9 8 7 6 5 4 3 2 1 0
Sie können auch verwenden
((
x
->
)
Ausgabe: 9 8 7 6 5 4 3 2 1 0
Ebenso können Sie viele Methoden ausprobieren, um diesen Befehl erfolgreich auszuführen.
|
Hier - ist der unäre Post-Dekrement-Operator.
während (x--> 0) // x auf 0 geht
{
printf ("% d", x);
}}
Zu Beginn wird die Bedingung als bewertet
(x> 0) // 10> 0
Da die Bedingung nun erfüllt ist, wird sie mit einem dekrementierten Wert in die Schleife eingegeben
x-- // x = 9
Deshalb ist der erste gedruckte Wert 9
Und so weiter. In der letzten Schleife ist x = 1, also ist die Bedingung wahr. Gemäß dem unären Operator wurde der Wert zum Zeitpunkt des Drucks auf x = 0 geändert.
Nun ist x = 0, wodurch die Bedingung (x> 0) als falsch ausgewertet wird und die while-Schleife beendet wird.
|
Dies -> ist überhaupt kein Operator. Wir haben einen Operator wie ->, aber nicht wie ->. Es ist nur eine falsche Interpretation von while (x--> 0), was einfach bedeutet, dass x den Post-Dekrement-Operator hat und diese Schleife läuft, bis sie größer als Null ist.
Eine andere einfache Möglichkeit, diesen Code zu schreiben, wäre while (x--). Die while-Schleife stoppt immer dann, wenn eine falsche Bedingung vorliegt, und hier gibt es nur einen Fall, d. H. 0. Sie stoppt also, wenn der x-Wert auf Null dekrementiert wird.
|
Sehr aktive Frage. Verdiene 10 Reputationen, um diese Frage zu beantworten. Die Reputationsanforderung schützt diese Frage vor Spam und nicht beantworteten Aktivitäten.
Nicht die Antwort, die Sie suchen? Durchsuchen Sie andere Fragen, die mit C ++ C-Operatoren gekennzeichnet sind, und befolgen Sie Ihre eigenen Fragen.